YES 1.733 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



HASKELL
  ↳ LR

mainModule List
  ((group :: [() ->  [[()]]) :: [() ->  [[()]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy [] []
groupBy eq (x : xs
(x : ys: groupBy eq zs where 
vv10 span (eq x) xs
ys (\(ys,_) ->ys) vv10
zs (\(_,zs) ->zs) vv10


module Maybe where
  import qualified List
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\(_,zs)→zs

is transformed to
zs0 (_,zs) = zs

The following Lambda expression
\(ys,_)→ys

is transformed to
ys0 (ys,_) = ys

The following Lambda expression
\(_,zs)→zs

is transformed to
zs1 (_,zs) = zs

The following Lambda expression
\(ys,_)→ys

is transformed to
ys1 (ys,_) = ys



↳ HASKELL
  ↳ LR
HASKELL
      ↳ BR

mainModule List
  ((group :: [() ->  [[()]]) :: [() ->  [[()]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy [] []
groupBy eq (x : xs
(x : ys: groupBy eq zs where 
vv10 span (eq x) xs
ys ys0 vv10
ys0 (ys,_) ys
zs zs0 vv10
zs0 (_,zszs


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.
Binding Reductions:
The bind variable of the following binding Pattern
xs@(wu : wv)

is replaced by the following term
wu : wv



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
HASKELL
          ↳ COR

mainModule List
  ((group :: [() ->  [[()]]) :: [() ->  [[()]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy vw [] []
groupBy eq (x : xs
(x : ys: groupBy eq zs where 
vv10 span (eq x) xs
ys ys0 vv10
ys0 (ys,vxys
zs zs0 vv10
zs0 (vy,zszs


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False

The following Function with conditions
span p [] = ([],[])
span p (wu : wv)
 | p wu
 = (wu : ys,zs)
 | otherwise
 = ([],wu : wv)
where 
vu43  = span p wv
ys  = ys1 vu43
ys1 (ys,wx) = ys
zs  = zs1 vu43
zs1 (ww,zs) = zs

is transformed to
span p [] = span3 p []
span p (wu : wv) = span2 p (wu : wv)

span2 p (wu : wv) = 
span1 p wu wv (p wu)
where 
span0 p wu wv True = ([],wu : wv)
span1 p wu wv True = (wu : ys,zs)
span1 p wu wv False = span0 p wu wv otherwise
vu43  = span p wv
ys  = ys1 vu43
ys1 (ys,wx) = ys
zs  = zs1 vu43
zs1 (ww,zs) = zs

span3 p [] = ([],[])
span3 xv xw = span2 xv xw



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
HASKELL
              ↳ LetRed

mainModule List
  ((group :: [() ->  [[()]]) :: [() ->  [[()]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy vw [] []
groupBy eq (x : xs
(x : ys: groupBy eq zs where 
vv10 span (eq x) xs
ys ys0 vv10
ys0 (ys,vxys
zs zs0 vv10
zs0 (vy,zszs


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
(x : ys: groupBy eq zs
where 
vv10  = span (eq xxs
ys  = ys0 vv10
ys0 (ys,vx) = ys
zs  = zs0 vv10
zs0 (vy,zs) = zs

are unpacked to the following functions on top level
groupByZs xx xy xz = groupByZs0 xx xy xz (groupByVv10 xx xy xz)

groupByYs0 xx xy xz (ys,vx) = ys

groupByZs0 xx xy xz (vy,zs) = zs

groupByVv10 xx xy xz = span (xx xyxz

groupByYs xx xy xz = groupByYs0 xx xy xz (groupByVv10 xx xy xz)

The bindings of the following Let/Where expression
span1 p wu wv (p wu)
where 
span0 p wu wv True = ([],wu : wv)
span1 p wu wv True = (wu : ys,zs)
span1 p wu wv False = span0 p wu wv otherwise
vu43  = span p wv
ys  = ys1 vu43
ys1 (ys,wx) = ys
zs  = zs1 vu43
zs1 (ww,zs) = zs

are unpacked to the following functions on top level
span2Ys yu yv = span2Ys1 yu yv (span2Vu43 yu yv)

span2Zs yu yv = span2Zs1 yu yv (span2Vu43 yu yv)

span2Zs1 yu yv (ww,zs) = zs

span2Span1 yu yv p wu wv True = (wu : span2Ys yu yv,span2Zs yu yv)
span2Span1 yu yv p wu wv False = span2Span0 yu yv p wu wv otherwise

span2Vu43 yu yv = span yu yv

span2Span0 yu yv p wu wv True = ([],wu : wv)

span2Ys1 yu yv (ys,wx) = ys



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
HASKELL
                  ↳ Narrow

mainModule List
  (group :: [() ->  [[()]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a ->  [[a]]
group groupBy (==)

  groupBy :: (a  ->  a  ->  Bool ->  [a ->  [[a]]
groupBy vw [] []
groupBy eq (x : xs(x : groupByYs eq x xs: groupBy eq (groupByZs eq x xs)

  
groupByVv10 xx xy xz span (xx xy) xz

  
groupByYs xx xy xz groupByYs0 xx xy xz (groupByVv10 xx xy xz)

  
groupByYs0 xx xy xz (ys,vxys

  
groupByZs xx xy xz groupByZs0 xx xy xz (groupByVv10 xx xy xz)

  
groupByZs0 xx xy xz (vy,zszs


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_span2Ys(:(@0, yw3111)) → new_span2Zs(yw3111)
new_span2Zs(:(@0, yw3111)) → new_span2Ys(yw3111)
new_span2Zs(:(@0, yw3111)) → new_span2Zs(yw3111)
new_span2Ys(:(@0, yw3111)) → new_span2Ys(yw3111)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
QDP
                        ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

new_groupBy(:(yw30, yw31)) → new_groupBy(new_groupByZs0(yw30, yw31))

The TRS R consists of the following rules:

new_span2Zs0(:(@0, yw3111)) → new_span2Zs1(yw3111, new_span2Ys0(yw3111), new_span2Zs0(yw3111))
new_span2Ys1(yw3111, yw5, yw4) → :(@0, yw5)
new_groupByZs0(yw30, []) → []
new_groupByZs0(@0, :(@0, yw311)) → new_span2Zs0(yw311)
new_span2Ys0([]) → []
new_span2Zs1(yw3111, yw7, yw6) → yw6
new_span2Zs0([]) → []
new_span2Ys0(:(@0, yw3111)) → new_span2Ys1(yw3111, new_span2Ys0(yw3111), new_span2Zs0(yw3111))

The set Q consists of the following terms:

new_span2Zs1(x0, x1, x2)
new_groupByZs0(@0, :(@0, x0))
new_span2Ys0([])
new_span2Zs0(:(@0, x0))
new_span2Ys1(x0, x1, x2)
new_span2Ys0(:(@0, x0))
new_span2Zs0([])
new_groupByZs0(x0, [])

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_groupBy(:(yw30, yw31)) → new_groupBy(new_groupByZs0(yw30, yw31))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [25]:

POL(:(x1, x2)) = 1 + x1   
POL(@0) = 0   
POL([]) = 0   
POL(new_groupBy(x1)) = x1   
POL(new_groupByZs0(x1, x2)) = 0   
POL(new_span2Ys0(x1)) = 1 + x1   
POL(new_span2Ys1(x1, x2, x3)) = 1   
POL(new_span2Zs0(x1)) = 0   
POL(new_span2Zs1(x1, x2, x3)) = x3   

The following usable rules [17] were oriented:

new_span2Zs0([]) → []
new_span2Zs0(:(@0, yw3111)) → new_span2Zs1(yw3111, new_span2Ys0(yw3111), new_span2Zs0(yw3111))
new_groupByZs0(yw30, []) → []
new_span2Zs1(yw3111, yw7, yw6) → yw6
new_groupByZs0(@0, :(@0, yw311)) → new_span2Zs0(yw311)
new_span2Ys1(yw3111, yw5, yw4) → :(@0, yw5)
new_span2Ys0(:(@0, yw3111)) → new_span2Ys1(yw3111, new_span2Ys0(yw3111), new_span2Zs0(yw3111))



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPOrderProof
QDP
                            ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_span2Zs0(:(@0, yw3111)) → new_span2Zs1(yw3111, new_span2Ys0(yw3111), new_span2Zs0(yw3111))
new_span2Ys1(yw3111, yw5, yw4) → :(@0, yw5)
new_groupByZs0(yw30, []) → []
new_groupByZs0(@0, :(@0, yw311)) → new_span2Zs0(yw311)
new_span2Ys0([]) → []
new_span2Zs1(yw3111, yw7, yw6) → yw6
new_span2Zs0([]) → []
new_span2Ys0(:(@0, yw3111)) → new_span2Ys1(yw3111, new_span2Ys0(yw3111), new_span2Zs0(yw3111))

The set Q consists of the following terms:

new_span2Zs1(x0, x1, x2)
new_groupByZs0(@0, :(@0, x0))
new_span2Ys0([])
new_span2Zs0(:(@0, x0))
new_span2Ys1(x0, x1, x2)
new_span2Ys0(:(@0, x0))
new_span2Zs0([])
new_groupByZs0(x0, [])

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.